﻿#include<iostream>
#include<string>
using namespace std;
//
//class Person
//{
//public:
//	void Print()
//	{
//		cout << "name:" << _name << endl;
//		cout << "age:" << _age << endl;
//	}
//protected:
//	string _name = "peter";   //姓名
//private:
//	int _age = 18;
//};
//
//class Student :public Person   //公有继承
//{
//public:
//	void func()
//	{
//		//父类的私有成员继承下来不可见的意思：内存上子类对象有这个成员，
//		//但是语法规定了我们不能去访问
//		cout << _age << endl;
//	}
//protected:
//	int _stuid; //学号
//};
//
//class Teacher :public Person
//{
//protected:
//	int _jobid; //工号
//};
//
//int main()
//{
//	Student s;
//	Teacher t;
//
//	s.Print();
//	t.Print();
//	s._name;
//	return 0;
//}

//赋值兼容规则
//class Person
//{
//
//public:
//	string _name; //姓名
//	string _sex;  //性别
//	int _age;     //年龄
//
//};
//
//class Student :public Person
//{
//public:
//	int _No; //学号
//};
//
//int main()
//{
//	Person p;
//	Student s;
//	s._name = "张三";
//	s._sex = "男";
//	s._age = 18;
//
//	p = s;  //子类可以赋值给父类    切片
//	s = p;  //父类不可以给子类赋值   不行
//
//	Person* ptr = &s;
//	Person& ref = s;
//
//	return 0;
//}


//Student 的——num和 Person的_num 构成隐藏关系，可以看出这样代码虽然能跑，但是
//非常容易混淆
//class Person
//{
//protected:
//	string _name = "小李子";  //姓名
//	int _num = 111;          //身份证号
//
//};
//
//class Student :public Person
//{
//public:
//	void Print()
//	{
//		cout << "姓名" << _name << endl;
//		cout << "身份证号：" << Person::_num << endl;
//		cout << "学号：" << _num << endl;
//	}
//protected:
//	int _num = 999;  //学号
//};
//
//class A
//{
//public:
//
//	void fun()
//	{
//		cout << "func" << endl;
//	}
//};
//
//class B :public A
//{
//public:
//	void fun(int i)
//	{
//		cout << "func(int i)->" << i << endl;
//	}
//};
//
//void Test()
//{
//	B b;
//	b.fun(10);
//	b.A::fun();
//}
//
//int main()
//{
//	Student s;
//	s.Print();
//
//	Person p = s;
//	return 0;
//}

//class Person
//{
//public:
//	//构造函数
//	Person(const char* name)
//		:_name(name)
//	{
//		cout << "Person()" << endl;
//	}
//
//	//拷贝构造
//	Person(const Person& p)
//		:_name(p._name)
//	{
//		cout << "Person(const Person& p)" << endl;
//	}
//
//	//赋值重载
//	Person& operator=(const Person& p)
//	{
//		cout << "Person operator=(const Person& p)" << endl;
//		if (this != &p)
//			_name = p._name;
//
//		return *this;
//	}
//
//	//析构函数
//	~Person()   //因为多态的原因，任何类析构函数名都会被统一处理成 destructor()
//	{
//		cout << "~Person()" << endl;
//	}
//protected:
//	string _name;
//};
//
//class Student :public Person
//{
//public:
//	Student(const char* name, int id)
//		:Person(name)
//		, _id(id)
//	{
//		//调用父类构造函数初始化继承父类部分
//		//再初始化自己的成员
//		cout << "Student()" << endl;
//	}
//	Student(const Student& s)
//		:Person(s)  //->s 传递给 Person& s是一个切片行为
//		, _id(s._id)
//	{
//		//类似构造函数
//		cout << "Student(const Student& s)" << endl;
//	}
//	//s1 = s3;
//	Student& operator=(const Student& s)
//	{
//		//同上
//		if (this != &s)
//		{
//			//小心这里是隐藏
//			Person::operator=(s);
//			_id = s._id;
//		}
//		cout << "Studnet& operator=(const Student& s)" << endl;
//		return *this;
//	}
//	~Student() //编译器认为子类的析构函数和父类的析构函数构成隐藏
//	{
//		//Person::~Person() ;//这里想调用，需要指定父类的
//		//清理自己的
//		// delete ptr;
//		cout << "~Student()" << endl;
//		//为了保证析构时，保持先子再父的后进先出的顺序析构
//		//子类析构函数完成后，会自动去调用父类的析构函数
//	}
//private:int _id;
//};
//
//int main()
//{
//	Student s1("张三",1);
//	Student s2(s1);
//	Student s3("李四", 2);
//	s1 = s3;
//
//
//	return 0;
//}

//设计出一个类，让这个类不能被继承：使父类的构造函数私有，这个类就不可被继承，因为不能生成对象

